home *** CD-ROM | disk | FTP | other *** search
/ Workbench Design / WB Collection.iso / workbench werkzeuge / bildschirmschoner / snowblank / source / xsnow / blank.c next >
C/C++ Source or Header  |  1996-04-07  |  13KB  |  505 lines
  1. /* --------------------------------------------------------------------
  2.  *
  3.  *             A christmas blanker inspired by xsnow
  4.  *
  5.  *     This is an advanced but slower version compared to snow
  6.  *
  7.  *    initialization/cleanup code copied from the dragon module
  8.  *      (dragon module: (C)Alexander Kneer and Michael D. Bayne)
  9.  * 
  10.  * -------------------------------------------------------------------- */
  11.  
  12.  
  13. #include <exec/memory.h>
  14. #include <math.h>
  15. #include <stdlib.h>
  16.  
  17. #include "/includes.h"
  18.  
  19. #define STAGES 2        /* Number of different shapes */
  20. #define BLANKDELAY 100        /* This many snowflakes are displayed before
  21.                  * we check if to continue blanking */
  22. #define COUNTLIMIT 6        /* max. number of moves in one direction */
  23. #define COUNTMIN 1        /* min. number of moves in one direction */
  24.  
  25. /* random generation function macros */
  26. #define COUNTFUNC RangeRand(COUNTLIMIT-COUNTMIN)+COUNTMIN
  27. #define DXFUNC    RangeRand(5)-2;
  28. #define DYFUNC    RangeRand(2)+1;
  29.  
  30. typedef enum { false, true, random } bool;
  31.  
  32. bool BIGFLAKES;
  33. int  NUMSNOW;
  34. bool COLLECT;
  35. bool SHOWSTARS;
  36. bool SHOWSNOWMEN;
  37. bool SHOWTREES;
  38. bool SHOWBG;
  39. int  NUMOBJ;
  40.  
  41.  
  42. int patx[10] = {  -1,-1, 1, 1, 0  , -1, 1, 0, 0, 0 };
  43. int paty[10] = {  -1, 1,-1, 1, 0  ,  0, 0, 1,-1, 0 };
  44.  
  45. int *collect;
  46. int *starx;
  47. int *stary;
  48. int starnum;
  49.  
  50. typedef struct 
  51.   { int x,y;            /* The current coordinates */
  52.     int dx,dy;            /* Movement direction is (dx,dy) */
  53.     int count;            /* How long to keep direction dx */
  54.     int stage;            /* STAGES different shapes */
  55.     short int mem[5];           /* stores the pixels below its shape */
  56.   } snowflake;
  57.  
  58.  
  59. /* Color pens */
  60. #define CBLACK 0
  61. #define CWHITE 1
  62. #define CGREEN 2
  63. #define CBROWN 3
  64. #define CDGREY 5
  65. #define CMGREY 6
  66. #define CLGREY 7
  67. #define CYELLOW 4
  68.  
  69.  
  70. Triplet *ColorTable = 0L;
  71.  
  72.  
  73. #define PR_FLAKE   0
  74. #define PR_BIG     2
  75. #define PR_COLLECT 3
  76. #define PR_STARS   5
  77. #define PR_BG      6
  78. #define PR_SNMAN   8
  79. #define PR_TREE    9
  80. #define PR_OBJ     11
  81. #define PR_MODE    13
  82.  
  83. VOID Defaults( PrefObject *Prefs )
  84. {
  85.   Prefs[PR_FLAKE].po_Level = 200;
  86.   Prefs[PR_BIG].po_Level = 1;
  87.   Prefs[PR_COLLECT].po_Level = 1;
  88.   Prefs[PR_STARS].po_Level = 1;
  89.   Prefs[PR_BG].po_Level = 1;
  90.   Prefs[PR_SNMAN].po_Level = 1;
  91.   Prefs[PR_OBJ].po_Level = 20;
  92.   Prefs[PR_TREE].po_Level = 1;
  93.   Prefs[PR_MODE].po_ModeID = getTopScreenMode();
  94. }
  95.  
  96.  
  97. /* Remove a single snowflake's image from the screen */
  98. __inline void undraw(snowflake *flake, struct RastPort *rp)
  99. { 
  100.   if (BIGFLAKES)
  101.     {
  102.       int *startx = patx + 5*(flake->stage);
  103.       int *starty = paty + 5*(flake->stage);
  104.       int i;
  105.       for (i=0; i<5; i++)
  106.     { if (flake->mem[i] != -1)
  107.             { SetAPen(rp,flake->mem[i]);
  108.               WritePixel(rp,flake->x+(*startx),flake->y+(*starty));
  109.             }
  110.          startx++;
  111.       starty++;
  112.     }
  113.     }
  114.   else
  115.     { if (flake->mem[0] != -1)
  116.         { SetAPen(rp,flake->mem[0]);
  117.           WritePixel(rp,flake->x,flake->y);
  118.         }
  119.     }
  120. }
  121.  
  122.  
  123. __inline void WriteLine(struct RastPort *rp, int width, int height, int x, int y, int scale, 
  124.                         int x1, int y1, int x2, int y2)
  125. { x1=x1*4*scale; y1=y1*4*scale; x2=x2*4*scale; y2=y2*4*scale;
  126.   /* all coordinates are now 1.000 times too big */
  127.   Move(rp,x+x1/1000,y+y1/1000);
  128.   Draw(rp,x+x2/1000,y+y2/1000);
  129. }
  130.  
  131.  
  132. void draw_tree(struct RastPort *rp, int width, int height)
  133. { int x,y;
  134.   int scale;
  135.   x = RangeRand(width-42);
  136.   y = RangeRand((height*3)/4-42)+height/4;
  137.   scale = (y*1000)/height;
  138.   SetAPen(rp,CBROWN);
  139.   WriteLine(rp,width,height,x,y,scale,4,10,6,10);
  140.   WriteLine(rp,width,height,x,y,scale,4,10,4,8);
  141.   WriteLine(rp,width,height,x,y,scale,6,10,6,8);
  142.   SetAPen(rp,CGREEN);
  143.   WriteLine(rp,width,height,x,y,scale,0,8,10,8);
  144.   WriteLine(rp,width,height,x,y,scale,0,8,3,6);
  145.   WriteLine(rp,width,height,x,y,scale,10,8,7,6);
  146.   WriteLine(rp,width,height,x,y,scale,3,6,1,6);
  147.   WriteLine(rp,width,height,x,y,scale,7,6,9,6);
  148.   WriteLine(rp,width,height,x,y,scale,1,6,3,4);
  149.   WriteLine(rp,width,height,x,y,scale,9,6,7,4);
  150.   WriteLine(rp,width,height,x,y,scale,3,4,2,4);
  151.   WriteLine(rp,width,height,x,y,scale,7,4,8,4);
  152.   WriteLine(rp,width,height,x,y,scale,2,4,4,2);
  153.   WriteLine(rp,width,height,x,y,scale,8,4,6,2);
  154.   WriteLine(rp,width,height,x,y,scale,4,2,3,2);
  155.   WriteLine(rp,width,height,x,y,scale,6,2,7,2);
  156.   WriteLine(rp,width,height,x,y,scale,3,2,5,0);
  157.   WriteLine(rp,width,height,x,y,scale,7,2,5,0);
  158. }
  159.  
  160.  
  161. __inline void WriteBall(struct RastPort *rp, int x, int y, int scale, 
  162.                         int x1, int y1, int r)
  163. { int i,j;
  164.   x1=x1*4*scale; y1=y1*4*scale; r=(r*4*scale)/1000;
  165.   /* all coordinates are now 1.000 times too big */
  166.   for (j=1; j<r; j++)
  167.     { i=r+1-j;
  168.       SetAPen(rp,16-((i*8)/r));
  169.       DrawEllipse(rp,x+x1/1000,y+y1/1000,i,i);
  170.     }
  171. }
  172.  
  173.  
  174. void draw_snowman(struct RastPort *rp, int width, int height)
  175. { int x,y;
  176.   int scale;
  177.   x = RangeRand(width-42);
  178.   y = RangeRand((height*3)/4-42)+height/4;
  179.   scale = (y*1000)/height;
  180.   SetAPen(rp,CLGREY);
  181.   /*if (scale > 400) WriteLine(rp,width,height,x,y,scale,1,4,7,4);*/
  182.   WriteBall(rp,x,y,scale,4,7,3);
  183.   WriteBall(rp,x,y,scale,4,4,2);
  184.   WriteBall(rp,x,y,scale,4,2,1);
  185. }
  186.  
  187.  
  188.  
  189. /* draw a winterly landscape with everything and more :) */
  190. LONG draw_landscape(struct Screen *scr, int width, int height, struct RastPort *rp)
  191. { int numobj,i;
  192.   LONG flg_end;
  193.  
  194.   /* first: the landscape */
  195.     { if (SHOWBG)
  196.         { int x,y;
  197.           int *hei = malloc(sizeof(int)*width);
  198.           hei[0]=0;
  199.           for (i=1; i<width; i++)
  200.             { hei[i] = hei[i-1]+RangeRand(3)-1;
  201.             }
  202.           for (y=height/4; y<height; y++)
  203.             { for (x=0; x<width; x++)
  204.                 { int val = ((y+hei[x]) * 100) / height;
  205.                   val = val - val/8 + RangeRand(val/4);
  206.                   if (val<0) val = 0;  
  207.                   val = (val * 8)/100;
  208.                   if (val<0) val = 0;
  209.                   if (val>7) val = 7;
  210.                   if (!val) SetAPen(rp,0); 
  211.                   else SetAPen(rp,val+8);
  212.                   WritePixel(rp,x,y);
  213.                 }
  214.               for (i=1; i<width; i++)
  215.                 { if (!RangeRand(3)) hei[i] = hei[i]+RangeRand(3)-1;
  216.                 }              
  217.           flg_end = ContinueBlanking();
  218.           ScreenToFront(scr);
  219.           if (flg_end != OK)
  220.                 { free(hei); return flg_end; }
  221.             }
  222.         }
  223.       /* else leave the background black */
  224.     }
  225.  
  226.   /* possibly stars */
  227.   if (SHOWSTARS)
  228.     { int count = RangeRand(50)+50;
  229.       int i;
  230.       starx = malloc(count*sizeof(int));
  231.       stary = malloc(count*sizeof(int));
  232.  
  233.       SetAPen(rp,CYELLOW);
  234.       for (i=0; i<count; i++)
  235.         { int x,y;
  236.           do { x = RangeRand(width);
  237.                y = RangeRand(height/4);
  238.              } while (ReadPixel(rp,x,y) != CBLACK);
  239.           WritePixel(rp,x,y);
  240.           starx[i] = x;
  241.           stary[i] = y;
  242.         } 
  243.       starnum = count;
  244.     }
  245.  
  246.   /* Draw some objects */
  247.   numobj = RangeRand(NUMOBJ/2)+NUMOBJ/2;
  248.   for (i=0; i<numobj; i++)
  249.     { switch(RangeRand(4))
  250.         { case 0: case 1: case 2: if (SHOWTREES)
  251.                                     draw_tree(rp,width,height); break;
  252.           case 3:                 if (SHOWSNOWMEN) 
  253.                                     draw_snowman(rp,width,height); break;
  254.         }
  255.     } 
  256.   return OK;
  257. }
  258.  
  259.  
  260. /* Draw a single snowflake's image to the screen */
  261. __inline void draw(snowflake *flake, struct RastPort *rp)
  262. { 
  263.   if (BIGFLAKES)
  264.     {
  265.       int *startx = patx + 5*(flake->stage);
  266.       int *starty = paty + 5*(flake->stage);
  267.       int i;
  268.       SetAPen(rp,1);
  269.       for (i=0; i<5; i++)
  270.     { int xx = flake->x+(*startx);
  271.           int yy = flake->y+(*starty);
  272.           flake->mem[i] = ReadPixel(rp,xx,yy);
  273.           if (flake->mem[i] == CWHITE)
  274.             { flake->mem[i] = -1;
  275.             }
  276.           else
  277.             WritePixel(rp,xx,yy);
  278.       startx++;
  279.       starty++;
  280.     }
  281.     }
  282.   else
  283.     { flake->mem[0] = ReadPixel(rp,flake->x,flake->y);
  284.       if (flake->mem[0] == CWHITE)
  285.         { flake->mem[0] = -1;
  286.         }
  287.       else
  288.         { SetAPen(rp,1);
  289.           WritePixel(rp,flake->x,flake->y);
  290.         }
  291.     }
  292. }
  293.  
  294.  
  295. /* change the position of a snowflake. If it leaves [0..width]x[0..height],
  296.  * generate a new one with coordinates (<random>,0) */
  297. __inline void update(snowflake *curr, int width, int height, struct RastPort *rp)
  298. { bool gen_new;
  299.   int oldx = curr->x;
  300.   if (curr->count > 0)
  301.     { curr->y = curr->y + curr->dy;
  302.       if (curr->y >= height-1)
  303.     { gen_new = true;
  304.     }
  305.       else
  306.     { curr->x = curr->x + curr->dx;
  307.       if (curr->x < 1 || curr->x >= width-1)
  308.         { gen_new = true;
  309.         }
  310.       else 
  311.         { gen_new = false;
  312.           (curr->count)--;
  313.           if (curr->count <= 0)
  314.         { curr->dx = DXFUNC;
  315.           curr->count = COUNTFUNC;
  316.         }
  317.           if (curr->stage)
  318.         { curr->stage--;
  319.         }
  320.           else
  321.         { curr->stage = STAGES-1;
  322.         }
  323.         }
  324.     }
  325.     }
  326.   
  327.   /* do we have to compute a new flake? */
  328.   if (gen_new)
  329.     { if (collect && curr->y > height-3)
  330.     { collect[oldx]--;
  331.       if (collect[oldx]<height-20)
  332.         { collect[oldx]=height-20;
  333.         }
  334.       
  335.       curr->x = oldx;
  336.       curr->y = collect[oldx];
  337.       draw(curr,rp);
  338.     }
  339.       curr->x = RangeRand(width-2)+1;
  340.       curr->y = 1;
  341.       curr->dx = DXFUNC;
  342.       curr->dy = DYFUNC;
  343.       curr->count = COUNTFUNC;
  344.       curr->stage = RangeRand(STAGES);
  345.     }
  346. }
  347.  
  348.  
  349.  
  350.  
  351. LONG snow(struct Screen *scr, SHORT width, SHORT height)
  352. {
  353.   unsigned int i;
  354.   LONG flg_end;
  355.   snowflake *flake,*curr;
  356.   int blankcount;
  357.   bool firstpass = true;
  358.   struct RastPort *rp = &(scr->RastPort);
  359.  
  360.   starx = NULL; stary = NULL;
  361.   /* first draw a winterly landscape */
  362.   flg_end = draw_landscape(scr,width,height,rp);
  363.   if (flg_end != OK)
  364.     { if (starx) free(starx);
  365.       if (stary) free(stary);
  366.       return flg_end;
  367.     }
  368.  
  369.   /* initialize the snow array */
  370.   flake = malloc(NUMSNOW*sizeof(snowflake));
  371.   curr = flake;
  372.   for (i=0; i<NUMSNOW; i++)
  373.     { curr->x = RangeRand(width-2)+1;
  374.       curr->y = RangeRand(height-2)+1;
  375.       curr->dx = DXFUNC;
  376.       curr->dy = DYFUNC;
  377.       curr->count = COUNTFUNC;
  378.       curr->stage = RangeRand(STAGES);
  379.       curr++;
  380.     }
  381.  
  382.   /* and the collect array */
  383.   if (COLLECT)
  384.     { collect = malloc(sizeof(int)*width);
  385.       for (i=0; i<width; i++)
  386.         { collect[i] = height-2;
  387.         }
  388.       collect[0] = 0;
  389.       collect[width-1] = 0;
  390.     }
  391.   else
  392.     { collect = NULL;
  393.     }
  394.  
  395.   /* Update all snowflakes forever. Update includes removal from the screen,
  396.    * computation of new position, drawing on the screen */
  397.   blankcount = BLANKDELAY;
  398.   while (1)
  399.     { curr = flake;
  400.       { if (SHOWSTARS)
  401.           { int num = RangeRand(starnum);
  402.             int x = starx[num];
  403.             int y = stary[num];
  404.             int val = ReadPixel(rp,x,y);
  405.             if (val != CWHITE)
  406.               { if (val == CYELLOW)
  407.                   { SetAPen(rp,CBLACK);
  408.                   }
  409.                 else
  410.                   { SetAPen(rp,CYELLOW);
  411.                   }
  412.                 WritePixel(rp,x,y);
  413.               }
  414.           }
  415.       }
  416.               
  417.       for (i=0; i<NUMSNOW; i++)
  418.     { /* Remove curr's image */
  419.       if (!firstpass) undraw(curr,rp);
  420.       /* compute new position and appearance */
  421.       update(curr,width,height,rp);
  422.       /* and display it */
  423.       draw(curr,rp);
  424.       /* can we continue? */
  425.       if (!blankcount)
  426.         { blankcount = BLANKDELAY;
  427.           flg_end = ContinueBlanking();
  428.           ScreenToFront(scr);
  429.           if (flg_end != OK)
  430.         { free(flake);
  431.            if (collect) free(collect);
  432.                   if (starx) free(starx);
  433.                   if (stary) free(stary);
  434.           return flg_end;
  435.         }
  436.         }
  437.       else
  438.         { blankcount--;
  439.         }
  440.       curr++;
  441.     }
  442.       if (firstpass) firstpass = false;
  443.     }
  444.   return OK;            /* just for the compiler */
  445. }
  446.  
  447.  
  448. bool val(bool x)
  449. { if (x==random)
  450.     return RangeRand(2);
  451.   else return x;
  452. }
  453.  
  454.  
  455. LONG Blank( PrefObject *Prefs )
  456. {
  457.     struct Screen *Scr;
  458.     struct Window *Wnd;
  459.     LONG RetVal;
  460.     
  461.         BIGFLAKES   = val(Prefs[PR_BIG].po_Level); 
  462.     NUMSNOW     = Prefs[PR_FLAKE].po_Level;
  463.     COLLECT     = val(Prefs[PR_COLLECT].po_Level);
  464.         SHOWSNOWMEN = val(Prefs[PR_SNMAN].po_Level);
  465.         SHOWSTARS   = val(Prefs[PR_STARS].po_Level);
  466.         SHOWTREES   = val(Prefs[PR_TREE].po_Level);
  467.         SHOWBG      = val(Prefs[PR_BG].po_Level);
  468.         NUMOBJ      = Prefs[PR_OBJ].po_Level;
  469.  
  470.     if( Scr = OpenScreenTags( NULL, SA_Depth, 4,
  471.                              SA_Quiet, TRUE, SA_DisplayID, Prefs[PR_MODE].po_ModeID,
  472.                              SA_Behind, TRUE, SA_Overscan, OSCAN_STANDARD,
  473.                              TAG_DONE ))
  474.     {
  475.         SetRGB4(&( Scr->ViewPort ), 0, 0, 0, 0 );
  476.         ColorTable = RainbowPalette( Scr, 0L, 1L, 0L );
  477.         SetRGB4(&( Scr->ViewPort ), 1, 15, 15, 15 ); /* white */
  478.                 SetRGB4(&( Scr->ViewPort ), 2,  0,  10, 0 ); /* green */
  479.                 SetRGB4(&( Scr->ViewPort ), 3,  8,  5,  4 ); /* brown */
  480.                 SetRGB4(&( Scr->ViewPort ), 4, 15, 15,  8 ); /* yellow */
  481.                 SetRGB4(&( Scr->ViewPort ), 5,  4,  4,  4 ); /* dark grey */
  482.                 SetRGB4(&( Scr->ViewPort ), 6,  8,  8,  8 ); /* mid grey */
  483.                 SetRGB4(&( Scr->ViewPort ), 7,  12,  12,  12 ); /* light grey */
  484.                 { int i;
  485.                   for (i=8; i<16; i++)
  486.                     {
  487.                       SetRGB4(&( Scr->ViewPort ), i,  i-7,  i-7,  i-7); /* different gray */
  488.                     } 
  489.                 }
  490.         Wnd = BlankMousePointer( Scr );
  491.         
  492.         do
  493.             RetVal = snow( Scr, Scr->Width, Scr->Height );
  494.         while( RetVal == OK );
  495.         
  496.         UnblankMousePointer( Wnd );
  497.         RainbowPalette( 0L, ColorTable, 1L, 0L );
  498.         CloseScreen( Scr );
  499.     }
  500.     else
  501.         RetVal = FAILED;
  502.     
  503.     return RetVal;
  504. }
  505.